/*******************************************************************************
 * (c) Copyright 2010-2015 Microsemi SoC Products Group.  All rights reserved.
 * 
 * SmartFusion microcontroller subsystem (MSS) timer driver API.
 *
 * SVN $Revision: 7255 $
 * SVN $Date: 2015-03-18 10:18:30 +0530 (Wed, 18 Mar 2015) $
 */
/*=========================================================================*//**
 @mainpage SmartFusion MSS Timer Bare Metal Driver.

 @section intro_sec Introduction
 The SmartFusion microcontroller subsystem (MSS) includes a timer hardware
 block which can be used as two independent 32-bit timers or as a single
 64-bit timer in periodic or one-shot mode.

 This software driver provides a set of functions for controlling the MSS
 Timer as part of a bare metal system where no operating system is available.
 The drivers can be adapted for use as part of an operating system but the
 implementation of the adaptation layer between this driver and the operating
 system's driver model is outside the scope of this driver.

 @section theory_op Theory of Operation
 The MSS Timer can be used in one of two mutually exclusive modes; either as
 a single 64-bits timer or as two independent 32-bits timers. The MSS Timer
 can be used in either periodic mode or one-shot mode. A timer configured
 for periodic mode operations will generate an interrupt and reload its
 down-counter when it reaches 0. The timer will then continue decrementing from
 its reload value without waiting for the interrupt to be cleared. A timer
 configured for one-shot mode will only generate an interrupt once when its
 down-counter reaches 0. It must be explicitly reloaded to start decrementing
 again.

 The MSS Timer driver functions are grouped into the following categories:
 - Initialization and Configuration
 - Timer control
 - Interrupt control

 The MSS Timer driver provides three initialization functions:
 - MSS_TIM1_init()
 - MSS_TIM2_init()
 - MSS_TIM64_init()
 The MSS Timer driver is initialized through calls to these functions and at
 least one of them must be called before any other MSS Timer driver functions
 can be called.
 You should only use the MSS_TIM1_init() and MSS_TIM2_init() functions if you
 intend to use the timer in 32-bits mode. Use the MSS_TIM64_init() function is
 you intend to use the MSS Timer as a single 64-bits timer. The initialization
 functions take a single parameter specifying the operating mode of the timer
 being initialized.

 Once initialized a timer can be controlled using the following functions:
 - MSS_TIM1_load_immediate()
 - MSS_TIM1_load_background()
 - MSS_TIM1_get_current_value()
 - MSS_TIM1_start()
 - MSS_TIM1_stop()
 - MSS_TIM2_load_immediate()
 - MSS_TIM2_load_background()
 - MSS_TIM2_get_current_value()
 - MSS_TIM2_start()
 - MSS_TIM2_stop()
 - MSS_TIM64_load_immediate()
 - MSS_TIM64_load_background()
 - MSS_TIM64_get_current_value()
 - MSS_TIM64_start()
 - MSS_TIM64_stop()

 Timer interrupts are controlled using the following functions:
 - MSS_TIM1_enable_irq()
 - MSS_TIM1_disable_irq()
 - MSS_TIM1_clear_irq()
 - MSS_TIM2_enable_irq()
 - MSS_TIM2_disable_irq()
 - MSS_TIM2_clear_irq()
 - MSS_TIM64_enable_irq()
 - MSS_TIM64_disable_irq()
 - MSS_TIM64_clear_irq()

 The function prototypes for the timer interrupt handlers are:
 - void Timer1_IRQHandler( void )
 - void Timer2_IRQHandler( void )
 Entries for these interrupt handlers are provided in the SmartFusion CMSIS-PAL
 vector table. To add a Timer 1 interrupt handler, you must implement a
 Timer1_IRQHandler( ) function as part of your application code. To add a
 Timer 2 interrupt handler, you must implement a Timer2_IRQHandler( ) function
 as part of your application code. When using the MSS Timer as a 64-bit timer,
 you must implement a Timer1_IRQHandler( ) function as part of your
 application code. The Timer 2 interrupt is not used when the MSS Timer is
 configured as a 64-bit timer.

 *//*=========================================================================*/
#ifndef MSS_TIMER_H_
#define MSS_TIMER_H_

#include "../../CMSIS/a2fxxxm3.h"

#ifdef __cplusplus
extern "C"
{
#endif 

/*-------------------------------------------------------------------------*//**
 * Timer mode selection. This enumeration is used to select between the two
 * possible timer modes of operation: periodic and one-shot mode. It is used as
 * an argument to the MSS_TIM1_init(), MSS_TIM2_init() and MSS_TIM64_init()
 * functions.
 * MSS_TIMER_PERIODIC_MODE:
 *  In periodic mode the timer generates interrupts at constant intervals. On 
 *  reaching zero, the timer's counter is reloaded with a value held in a
 *  register and begins counting down again.
 * MSS_TIMER_ONE_SHOT_MODE:
 *  The timer generates a single interrupt in this mode. On reaching zero, the
 *  timer's counter halts until reprogrammed by the user.
 */
typedef enum __mss_timer_mode_t
{
	MSS_TIMER_PERIODIC_MODE = 0, MSS_TIMER_ONE_SHOT_MODE = 1
} mss_timer_mode_t;

/*-------------------------------------------------------------------------*//**
 The MSS_TIM1_init() function initializes the SmartFusion MSS Timer block for
 use as a 32-bit timer and selects the operating mode for Timer 1. This function
 takes the MSS Timer block out of reset in case this hasn抰 been done already,
 stops Timer 1, disables its interrupt and sets the Timer 1 operating mode.
 Please note that the SmartFusion MSS Timer block cannot be used both as a
 64-bit and 32-bit timer. Calling MSS_TIM1_init() will overwrite any previous
 configuration of the MSS Timer as a 64-bit timer.

 
 @param mode
 The mode parameter specifies whether the timer will operate in periodic or
 one-shot mode. Allowed values for this parameter are:
 - MSS_TIMER_PERIODIC_MODE
 - MSS_TIMER_ONE_SHOT_MODE
 */
static __INLINE void MSS_TIM1_init( mss_timer_mode_t mode )
{
	NVIC_DisableIRQ( Timer1_IRQn ); /* Disable timer 1 irq in the Cortex-M3 NVIC */

	SYSREG->SOFT_RST_CR &= ~SYSREG_TIMER_SOFTRESET_MASK; /* Take timer block out of reset */

	TIMER->TIM64_MODE = 0U; /* switch to 32 bits mode */

	TIMER_BITBAND->TIM1ENABLE = 0U; /* disable timer */
	TIMER_BITBAND->TIM1INTEN = 0U; /* disable interrupt */
	TIMER_BITBAND->TIM1MODE = (uint32_t)mode; /* set mode (continuous/one-shot) */

	TIMER->TIM1_RIS = 1U; /* clear timer 1 interrupt */
	NVIC_ClearPendingIRQ( Timer1_IRQn ); /* clear timer 1 interrupt within NVIC */
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM1_start() function enables Timer 1 and starts its down-counter
 decrementing from the load_value specified in previous calls to the
 MSS_TIM1_load_immediate() or MSS_TIM1_load_background() functions.
 Note: The MSS_TIM1_start() function is also used to resume the down-counter
 if previously stopped using MSS_TIM1_stop() function.
 */
static __INLINE void MSS_TIM1_start( void )
{
	TIMER_BITBAND->TIM1ENABLE = 1U; /* enable timer */
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM1_stop() function disables Timer 1 and stops its down-counter
 decrementing.
 */
static __INLINE void MSS_TIM1_stop( void )
{
	TIMER_BITBAND->TIM1ENABLE = 0U; /* disable timer */
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM1_get_current_value() returns the current value of the Timer 1
 down-counter.

 @return
 This function returns the 32-bits current value of the Timer 1 down-counter.
 */
static __INLINE uint32_t MSS_TIM1_get_current_value( void )
{
	return TIMER->TIM1_VAL;
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM1_load_immediate() function loads the value passed by the
 load_value parameter into the Timer 1 down-counter. The counter will decrement
 immediately from this value once Timer 1 is enabled. The MSS Timer will
 generate an interrupt when the counter reaches zero if Timer 1 interrupts
 are enabled. This function is intended to be used when Timer 1 is configured
 for one-shot mode to time a single delay.
 Note: The value passed by the load_value parameter is loaded immediately into
 the down-counter regardless of whether Timer 1 is operating in periodic
 or one-shot mode.
 
 @param load_value
 The load_value parameter specifies the value from which the Timer 1
 down-counter will start decrementing.
 */
static __INLINE void MSS_TIM1_load_immediate( uint32_t load_value )
{
	TIMER->TIM1_LOADVAL = load_value;
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM1_load_background() function is used to specify the value that will
 be reloaded into the Timer 1 down-counter the next time the counter reaches
 zero. This function is typically used when Timer 1 is configured for periodic
 mode operation to select or change the delay period between the interrupts
 generated by Timer 1.
 
 @param load_value
 The load_value parameter specifies the value that will be loaded into the
 Timer 1 down-counter the next time the down-counter reaches zero. The Timer
 1 down-counter will start decrementing from this value after the current
 count expires.
 */
static __INLINE void MSS_TIM1_load_background( uint32_t load_value )
{
	TIMER->TIM1_BGLOADVAL = load_value;
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM1_enable_irq() function is used to enable interrupt generation for
 Timer 1. This function also enables the interrupt in the Cortex-M3 interrupt
 controller. The Timer1_IRQHandler() function will be called when a Timer 1
 interrupt occurs.
 Note: A Timer1_IRQHandler() default implementation is defined, with
 weak linkage, in the SmartFusion CMSIS-PAL. You must provide your own
 implementation of the Timer1_IRQHandler() function, that will override the
 default implementation, to suit your application.
 */
static __INLINE void MSS_TIM1_enable_irq( void )
{
	TIMER_BITBAND->TIM1INTEN = 1U;
	NVIC_EnableIRQ( Timer1_IRQn );
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM1_disable_irq() function is used to disable interrupt generation
 for Timer 1. This function also disables the interrupt in the Cortex-M3
 interrupt controller.
 */
static __INLINE void MSS_TIM1_disable_irq( void )
{
	TIMER_BITBAND->TIM1INTEN = 0U;
	NVIC_DisableIRQ( Timer1_IRQn );
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM1_clear_irq() function is used to clear a pending interrupt from
 Timer 1. This function also clears the interrupt in the Cortex-M3 interrupt
 controller.
 Note: You must call the MSS_TIM1_clear_irq() function as part of your
 implementation of the Timer1_IRQHandler() Timer 1 interrupt service routine
 (ISR) in order to prevent the same interrupt event retriggering a call to the
 ISR.
 */
static __INLINE void MSS_TIM1_clear_irq( void )
{
	TIMER->TIM1_RIS = 1U;
	/*
	 To ensure all the previous instructions are completed, data barrier
	 instruction is used. The 揹sb� data barriers instruction completes,
	 only after all the previous instruction are completed.
	 */
	__ASM volatile ("dsb");
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM2_init() function initializes the SmartFusion MSS Timer block for
 use as a 32-bit timer and selects the operating mode for Timer 2. This function
 takes the MSS Timer block out of reset in case this hasn抰 been done already,
 stops Timer 2, disables its interrupt and sets the Timer 2 operating mode.
 Note: The SmartFusion MSS Timer block cannot be used both as a 64-bit and
 32-bit timer. Calling MSS_TIM2_init() will overwrite any previous
 configuration of the MSS Timer as a 64-bit timer.

 @param mode
 The mode parameter specifies whether the timer will operate in periodic or
 one-shot mode. Allowed values for this parameter are:
 - MSS_TIMER_PERIODIC_MODE
 - MSS_TIMER_ONE_SHOT_MODE
 */
static __INLINE void MSS_TIM2_init( mss_timer_mode_t mode )
{
	NVIC_DisableIRQ( Timer2_IRQn ); /* Disable timer 2 irq in the Cortex-M3 NVIC */

	SYSREG->SOFT_RST_CR &= ~SYSREG_TIMER_SOFTRESET_MASK; /* Take timer block out of reset */

	TIMER->TIM64_MODE = 0U; /* switch to 32 bits mode */

	TIMER_BITBAND->TIM2ENABLE = 0U; /* disable timer */
	TIMER_BITBAND->TIM2INTEN = 0U; /* disable interrupt */
	TIMER_BITBAND->TIM2MODE = (uint32_t)mode; /* set mode (continuous/one-shot) */

	TIMER->TIM2_RIS = 1U; /* clear timer 2 interrupt */
	NVIC_ClearPendingIRQ( Timer2_IRQn ); /* clear timer 2 interrupt within NVIC */
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM2_start() function enables Timer 2 and  starts its down-counter
 decrementing from the load_value specified in previous calls to the
 MSS_TIM2_load_immediate() or MSS_TIM2_load_background() functions.
 Note: The MSS_TIM2_start() function is also used to resume the down-counter
 if previously stopped using the MSS_TIM2_stop() function.
 */
static __INLINE void MSS_TIM2_start( void )
{
	TIMER_BITBAND->TIM2ENABLE = 1U; /* enable timer */
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM2_stop() function disables Timer 2 and stops its down-counter
 decrementing.
 */
static __INLINE void MSS_TIM2_stop( void )
{
	TIMER_BITBAND->TIM2ENABLE = 0U; /* disable timer */
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM2_get_current_value() returns the current value of the Timer 2
 down-counter.
 */
static __INLINE uint32_t MSS_TIM2_get_current_value( void )
{
	return TIMER->TIM2_VAL;
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM2_load_immediate() function loads the value passed by the
 load_value parameter into the Timer 2 down-counter. The counter will
 decrement immediately from this value once Timer 2 is enabled. The MSS Timer
 will generate an interrupt when the counter reaches zero if Timer 2
 interrupts are enabled. This function is intended to be used when Timer 2
 is configured for one-shot mode to time a single delay.
 Note: The value passed by the load_value parameter is loaded immediately
 into the down-counter regardless of whether Timer 2 is operating in
 periodic or one-shot mode.

 @param load_value
 The load_value parameter specifies the value from which the Timer 2
 down-counter will start decrementing.
 */
static __INLINE void MSS_TIM2_load_immediate(uint32_t load_value)
{
	TIMER->TIM2_LOADVAL = load_value;
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM2_load_background() function is used to specify the value that will
 be reloaded into the Timer 2 down-counter the next time the counter reaches
 zero. This function is typically used when Timer 2 is configured for periodic
 mode operation to select or change the delay period between the interrupts
 generated by Timer 2.

 @param load_value
 The load_value parameter specifies the value that will be loaded into the
 Timer 2 down-counter the next time the down-counter reaches zero. The Timer
 2 down-counter will start decrementing from this value after the current
 count expires.
 */
static __INLINE void MSS_TIM2_load_background(uint32_t load_value)
{
	TIMER->TIM2_BGLOADVAL = load_value;
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM2_enable_irq() function is used to enable interrupt generation for
 Timer 2. This function also enables the interrupt in the Cortex-M3 interrupt
 controller. The Timer2_IRQHandler() function will be called when a Timer 2
 interrupt occurs.
 Note: A Timer2_IRQHandler() default implementation is defined, with weak
 linkage, in the SmartFusion CMSIS-PAL. You must provide your own implementation
 of the Timer2_IRQHandler() function, that will override the default
 implementation, to suit your application.
 */
static __INLINE void MSS_TIM2_enable_irq(void)
{
	TIMER_BITBAND->TIM2INTEN = 1U;
	NVIC_EnableIRQ( Timer2_IRQn );
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM2_disable_irq() function is used to disable interrupt generation
 for Timer 2. This function also disables the interrupt in the Cortex-M3
 interrupt controller.
 */
static __INLINE void MSS_TIM2_disable_irq(void)
{
	TIMER_BITBAND->TIM2INTEN = 0U;
	NVIC_DisableIRQ(Timer2_IRQn);
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM2_clear_irq() function is used to clear a pending interrupt from
 Timer 2. This function also clears the interrupt in the Cortex-M3 interrupt
 controller.
 Note: You must call the MSS_TIM2_clear_irq() function as part of your
 implementation of the Timer2_IRQHandler() Timer 2 interrupt service routine
 (ISR) in order to prevent the same interrupt event re-triggering a call to the
 ISR.
 */
static __INLINE void MSS_TIM2_clear_irq(void)
{
	TIMER->TIM2_RIS = 1U;
	/*
	 To ensure all the previous instructions are completed, data barrier
	 instruction is used. The 揹sb� data barriers instruction completes,
	 only after all the previous instruction are completed.
	 */
	__ASM volatile ("dsb");
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM64_init() function initializes the MSS Timer block for use as
 a single 64-bit timer and selects the operating mode of the timer. This
 function takes the MSS Timer block out of reset in case this hasn抰 been done
 already, stops the timer, disables its interrupts and sets the timer's
 operating mode.
 Note: The MSS Timer block cannot be used both as a 64-bit and 32-bit timer.
 Calling MSS_TIM64_init() will overwrite any previous configuration of
 the MSS Timer as a 32-bit timer.

 @param mode
 The mode parameter specifies whether the timer will operate in periodic or
 one-shot mode. Allowed values for this parameter are:
 - MSS_TIMER_PERIODIC_MODE
 - MSS_TIMER_ONE_SHOT_MODE
 */
static __INLINE void MSS_TIM64_init(mss_timer_mode_t mode)
{
	NVIC_DisableIRQ(Timer1_IRQn); /* disable timer 1 interrupt within NVIC */
	NVIC_DisableIRQ(Timer2_IRQn); /* disable timer 2 interrupt within NVIC */

	SYSREG->SOFT_RST_CR &= ~SYSREG_TIMER_SOFTRESET_MASK; /* Take timer block out of reset */

	TIMER->TIM64_MODE = 1U; /* switch to 64 bits mode */

	TIMER_BITBAND->TIM64ENABLE = 0U; /* disable timer */
	TIMER_BITBAND->TIM64INTEN = 0U; /* disable interrupt */
	TIMER_BITBAND->TIM64MODE = (uint32_t)mode; /* set mode (continuous/one-shot) */

	TIMER->TIM1_RIS = 1U; /* clear timer 1 interrupt */
	TIMER->TIM2_RIS = 1U; /* clear timer 2 interrupt */
	NVIC_ClearPendingIRQ(Timer1_IRQn); /* clear timer 1 interrupt within NVIC */
	NVIC_ClearPendingIRQ(Timer2_IRQn); /* clear timer 2 interrupt within NVIC */
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM64_start() function enables the 64-bit timer and starts its
 down-counter decrementing from the load_value specified in previous calls to
 the MSS_TIM64_load_immediate() or MSS_TIM64_load_background() functions. The
 MSS_TIM64_start() function is also used to resume the down-counter if
 previously stop using MSS_TIM64_stop() function.
 Note: The MSS_TIM64_start() function is also used to resume the down-counter,
 if previously stopped using the MSS_TIM64_stop() function.
 */
static __INLINE void MSS_TIM64_start( void )
{
	TIMER_BITBAND->TIM64ENABLE = 1U; /* enable timer */
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM64_stop() function disables the 64-bit timer and stops its
 down-counter decrementing.
 */
static __INLINE void MSS_TIM64_stop( void )
{
	TIMER_BITBAND->TIM64ENABLE = 0U; /* disable timer */
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM64_get_current_value() is used to read the current value of the
 64-bit timer down-counter.

 @param load_value_u
 The load_value_u parameter is a pointer to a 32-bit variable where the upper
 32 bits of the current value of the 64-bit timer down-counter will be copied.

 @param load_value_l
 The load_value_l parameter is a pointer to a 32-bit variable where the lower
 32 bits of the current value of the 64-bit timer down-counter will be copied.
 
 Example:
 @code
 uint32_t current_value_u = 0;
 uint32_t current_value_l = 0;
 MSS_TIM64_get_current_value( &current_value_u, &current_value_l );
 @endcode
 */
static __INLINE void MSS_TIM64_get_current_value
(
		uint32_t * load_value_u,
		uint32_t * load_value_l
)
{
	*load_value_l = TIMER->TIM64_VAL_L;
	*load_value_u = TIMER->TIM64_VAL_U;
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM64_load_immediate() function loads the values passed by the
 load_value_u and load_value_l parameters into the 64-bit timer down-counter.
 The counter will decrement immediately from the concatenated 64-bit value once
 the 64-bit timer is enabled. The MSS Timer will generate an interrupt when the
 counter reaches zero if 64-bit timer interrupts are enabled. This function is
 intended to be used when the 64-bit timer is configured for one-shot mode to
 time a single delay.
 Note: The value passed by the load_value parameter is loaded immediately into
 the down-counter regardless of whether the 64-bit timer is operating in
 periodic or one-shot mode.

 @param load_value_u
 The load_value_u parameter specifies the upper 32 bits of the 64-bit timer
 load value from which the 64-bit timer down-counter will start decrementing.
 
 @param load_value_l
 The load_value_l parameter specifies the lower 32 bits of the 64-bit timer
 load value from which the 64-bit timer down-counter will start decrementing.
 */
static __INLINE void MSS_TIM64_load_immediate
(
		uint32_t load_value_u,
		uint32_t load_value_l
)
{
	TIMER->TIM64_LOADVAL_U = load_value_u;
	TIMER->TIM64_LOADVAL_L = load_value_l;
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM64_load_background() function is used to specify the 64-bit value
 that will be reloaded into the 64-bit timer down-counter the next time the
 counter reaches zero. This function is typically used when the 64-bit timer is
 configured for periodic mode operation to select or change the delay period
 between the interrupts generated by the 64-bit timer.

 @param load_value_u
 The load_value_u parameter specifies the upper 32 bits of the 64-bit timer
 load value. The concatenated 64-bit value formed from load_value_u and
 load_value_l will be loaded into the 64-bit timer down-counter the next
 time the down-counter reaches zero. The 64-bit timer down-counter will start
 decrementing from the concatenated 64-bit value after the current count
 expires.
 
 @param load_value_l
 The load_value_l parameter specifies the lower 32 bits of the 64-bit timer
 load value. The concatenated 64-bit value formed from load_value_u and
 load_value_l will be loaded into the 64-bit timer down-counter the next time
 the down-counter reaches zero. The 64-bit timer down-counter will start
 decrementing from the concatenated 64-bit value after the current count
 expires.
 */
static __INLINE void MSS_TIM64_load_background
(
		uint32_t load_value_u,
		uint32_t load_value_l
)
{
	TIMER->TIM64_BGLOADVAL_U = load_value_u;
	TIMER->TIM64_BGLOADVAL_L = load_value_l;
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM64_enable_irq() function is used to enable interrupt generation for
 the 64-bit timer. This function also enables the interrupt in the Cortex-M3
 interrupt controller. The Timer1_IRQHandler() function will be called when a
 64-bit timer interrupt occurs.
 Note: A Timer1_IRQHandler() default implementation is defined, with weak
 linkage, in the SmartFusion CMSIS-PAL. You must provide your own
 implementation of the Timer1_IRQHandler() function, that will override the
 default implementation, to suit your application.
 Note: The MSS_TIM64_enable_irq() function enables and uses Timer 1 interrupts
 for the 64-bit timer. Timer 2 interrupts remain disabled.
 */
static __INLINE void MSS_TIM64_enable_irq(void)
{
	TIMER_BITBAND->TIM64INTEN = 1U;
	NVIC_EnableIRQ(Timer1_IRQn);
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM64_disable_irq() function is used to disable interrupt generation
 for the 64-bit timer. This function also disables the interrupt in the
 Cortex-M3 interrupt controller.
 */
static __INLINE void MSS_TIM64_disable_irq(void)
{
	TIMER_BITBAND->TIM64INTEN = 0U;
	NVIC_DisableIRQ(Timer1_IRQn);
}

/*-------------------------------------------------------------------------*//**
 The MSS_TIM64_clear_irq() function is used to clear a pending interrupt from
 the 64-bit timer. This function also clears the interrupt in the Cortex-M3
 interrupt controller.
 Note: You must call the MSS_TIM64_clear_irq() function as part of your
 implementation of the Timer1_IRQHandler() 64-bit timer interrupt service
 routine (ISR) in order to prevent the same interrupt event retriggering a
 call to the ISR.
 */
static __INLINE void MSS_TIM64_clear_irq( void )
{
	TIMER->TIM64_RIS = 1U;
	/*
	 To ensure all the previous instructions are completed, data barrier
	 instruction is used. The 揹sb� data barriers instruction completes,
	 only after all the previous instruction are completed.
	 */
	__ASM volatile ("dsb");
}

#ifdef __cplusplus
}
#endif

#endif /*MSS_TIMER_H_*/
